package com.skyd.core.game.td;

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.Collection;

import com.skyd.core.vector.Vector2DF;

public abstract class TDActor extends TDEntity implements ITDActor {

	/**
	 * 初始值为false。 功能注释：是否已死亡
	 */
	private boolean _IsDead = false;

	/**
	 * 获取IsDead。 功能注释：是否已死亡
	 * 
	 * @return 当前的boolean类型的值
	 */
	public boolean getIsDead() {
		return _IsDead;
	}

	/**
	 * 设置IsDead。 功能注释：是否已死亡
	 * 
	 * @param value
	 *            要设置的boolean类型值
	 */
	public void setIsDead(boolean value) {
		_IsDead = value;
	}

	/**
	 * 设置IsDead为其默认值(false)。 功能注释：是否已死亡
	 */
	public void setIsDeadToDefault() {
		setIsDead(false);
	}

	/**
	 * 初始值为0。 功能注释：等级
	 */
	private int _Level = 0;

	/**
	 * 获取Level。 功能注释：等级
	 * 
	 * @return 当前的int类型的值
	 */
	public int getLevel() {
		return _Level;
	}

	/**
	 * 设置Level。 功能注释：等级
	 * 
	 * @param value
	 *            要设置的int类型值
	 */
	public void setLevel(int value) {
		_Level = value;
	}

	/**
	 * 设置Level为其默认值(0)。 功能注释：等级
	 */
	public void setLevelToDefault() {
		setLevel(0);
	}

	/**
	 * 初始值为0。 功能注释：生命值
	 */
	private int _HP = 0;

	/**
	 * 获取HP。 功能注释：生命值
	 * 
	 * @return 当前的int类型的值
	 */
	public int getHP() {
		return _HP;
	}

	/**
	 * 设置HP。 功能注释：生命值
	 * 
	 * @param value
	 *            要设置的int类型值
	 */
	public void setHP(int value) {
		_HP = value;
		if(!getIsDead()&&value<=0){
			setIsDead(true);
			OnDie(this);
		}
	}

	/**
	 * 设置HP为其默认值(0)。 功能注释：生命值
	 */
	public void setHPToDefault() {
		setHP(0);
	}

	/**
	 * 初始值为0。 功能注释：生命最大值
	 */
	private int _MaxHP = 0;

	/**
	 * 获取MaxHP。 功能注释：生命最大值
	 * 
	 * @return 当前的int类型的值
	 */
	public int getMaxHP() {
		return _MaxHP;
	}

	/**
	 * 设置MaxHP。 功能注释：生命最大值
	 * 
	 * @param value
	 *            要设置的int类型值
	 */
	public void setMaxHP(int value) {
		_MaxHP = value;
	}

	/**
	 * 设置MaxHP为其默认值(0)。 功能注释：生命最大值
	 */
	public void setMaxHPToDefault() {
		setMaxHP(0);
	}

	/**
	 * 初始值为0。 功能注释：攻击力
	 */
	private float _ATK = 0;

	/**
	 * 获取ATK。 功能注释：攻击力
	 * 
	 * @return 当前的float类型的值
	 */
	public float getATK() {
		return _ATK;
	}

	/**
	 * 设置ATK。 功能注释：攻击力
	 * 
	 * @param value
	 *            要设置的float类型值
	 */
	public void setATK(float value) {
		_ATK = value;
	}

	/**
	 * 设置ATK为其默认值(0)。 功能注释：攻击力
	 */
	public void setATKToDefault() {
		setATK(0);
	}

	/**
	 * 初始值为0。 功能注释：速度
	 */
	private float _Speed = 0;

	/**
	 * 获取Speed。 功能注释：速度
	 * 
	 * @return 当前的float类型的值
	 */
	public float getSpeed() {
		return _Speed;
	}

	/**
	 * 设置Speed。 功能注释：速度
	 * 
	 * @param value
	 *            要设置的float类型值
	 */
	public void setSpeed(float value) {
		_Speed = value;
	}

	/**
	 * 设置Speed为其默认值(0)。 功能注释：速度
	 */
	public void setSpeedToDefault() {
		setSpeed(0);
	}

	/**
	 * 初始值为0。 功能注释：攻击延迟
	 */
	private float _AttackDelay = 0;

	/**
	 * 获取AttackDelay。 功能注释：攻击延迟
	 * 
	 * @return 当前的float类型的值
	 */
	public float getAttackDelay() {
		return _AttackDelay;
	}

	/**
	 * 设置AttackDelay。 功能注释：攻击延迟
	 * 
	 * @param value
	 *            要设置的float类型值
	 */
	public void setAttackDelay(float value) {
		_AttackDelay = value;
	}

	/**
	 * 设置AttackDelay为其默认值(0)。 功能注释：攻击延迟
	 */
	public void setAttackDelayToDefault() {
		setAttackDelay(0);
	}

	/**
	 * 初始值为0。 功能注释：移动延迟
	 */
	private float _MoveDelay = 0;

	/**
	 * 获取MoveDelay。 功能注释：移动延迟
	 * 
	 * @return 当前的float类型的值
	 */
	public float getMoveDelay() {
		return _MoveDelay;
	}

	/**
	 * 设置MoveDelay。 功能注释：移动延迟
	 * 
	 * @param value
	 *            要设置的float类型值
	 */
	public void setMoveDelay(float value) {
		_MoveDelay = value;
	}

	/**
	 * 设置MoveDelay为其默认值(0)。 功能注释：移动延迟
	 */
	public void setMoveDelayToDefault() {
		setMoveDelay(0);
	}

	/**
	 * 初始值为0。 功能注释：朝向
	 */
	private float _Direction = 0;

	/**
	 * 获取Direction。 功能注释：朝向
	 * 
	 * @return 当前的float类型的值
	 */
	public float getDirection() {
		return _Direction;
	}

	/**
	 * 设置Direction。 功能注释：朝向
	 * 
	 * @param value
	 *            要设置的float类型值
	 */
	public void setDirection(float value) {
		_Direction = value;
	}

	/**
	 * 设置Direction为其默认值(0)。 功能注释：朝向
	 */
	public void setDirectionToDefault() {
		setDirection(0);
	}

	/**
	 * 初始值为0。 功能注释：范围
	 */
	private float _Range = 0;

	/**
	 * 获取Range。 功能注释：范围
	 * 
	 * @return 当前的float类型的值
	 */
	public float getRange() {
		return _Range;
	}

	/**
	 * 设置Range。 功能注释：范围
	 * 
	 * @param value
	 *            要设置的float类型值
	 */
	public void setRange(float value) {
		_Range = value;
	}

	/**
	 * 设置Range为其默认值(0)。 功能注释：范围
	 */
	public void setRangeToDefault() {
		setRange(0);
	}

	/**
	 * 初始值为0。 功能注释：半径
	 */
	private float _Radius = 0;

	/**
	 * 获取Radius。 功能注释：半径
	 * 
	 * @return 当前的float类型的值
	 */
	public float getRadius() {
		return _Radius;
	}

	/**
	 * 设置Radius。 功能注释：半径
	 * 
	 * @param value
	 *            要设置的float类型值
	 */
	public void setRadius(float value) {
		_Radius = value;
	}

	/**
	 * 设置Radius为其默认值(0)。 功能注释：半径
	 */
	public void setRadiusToDefault() {
		setRadius(0);
	}

	/**
	 * 初始值为1。 功能注释：价格
	 */
	private int _Price = 1;

	/**
	 * 获取Price。 功能注释：价格
	 * 
	 * @return 当前的int类型的值
	 */
	public int getPrice() {
		return _Price;
	}

	/**
	 * 设置Price。 功能注释：价格
	 * 
	 * @param value
	 *            要设置的int类型值
	 */
	public void setPrice(int value) {
		_Price = value;
	}

	/**
	 * 设置Price为其默认值(1)。 功能注释：价格
	 */
	public void setPriceToDefault() {
		setPrice(1);
	}

	/**
	 * 初始值为false。 功能注释：是否为空中单位
	 */
	private boolean _IsAirUnits = false;

	/**
	 * 获取IsAirUnits。 功能注释：是否为空中单位
	 * 
	 * @return 当前的boolean类型的值
	 */
	public boolean getIsAirUnits() {
		return _IsAirUnits;
	}

	/**
	 * 设置IsAirUnits。 功能注释：是否为空中单位
	 * 
	 * @param value
	 *            要设置的boolean类型值
	 */
	public void setIsAirUnits(boolean value) {
		_IsAirUnits = value;
	}

	/**
	 * 设置IsAirUnits为其默认值(false)。 功能注释：是否为空中单位
	 */
	public void setIsAirUnitsToDefault() {
		setIsAirUnits(false);
	}

	/**
	 * 初始值为true。 功能注释：是否可以攻击地面单位
	 */
	private boolean _IsCanAttackGroundUnits = true;

	/**
	 * 获取IsCanAttackGroundUnits。 功能注释：是否可以攻击地面单位
	 * 
	 * @return 当前的boolean类型的值
	 */
	public boolean getIsCanAttackGroundUnits() {
		return _IsCanAttackGroundUnits;
	}

	/**
	 * 设置IsCanAttackGroundUnits。 功能注释：是否可以攻击地面单位
	 * 
	 * @param value
	 *            要设置的boolean类型值
	 */
	public void setIsCanAttackGroundUnits(boolean value) {
		_IsCanAttackGroundUnits = value;
	}

	/**
	 * 设置IsCanAttackGroundUnits为其默认值(true)。 功能注释：是否可以攻击地面单位
	 */
	public void setIsCanAttackGroundUnitsToDefault() {
		setIsCanAttackGroundUnits(true);
	}

	/**
	 * 初始值为false。 功能注释：是否可以攻击空中单位
	 */
	private boolean _IsCanAttackAirUnits = false;

	/**
	 * 获取IsCanAttackAirUnits。 功能注释：是否可以攻击空中单位
	 * 
	 * @return 当前的boolean类型的值
	 */
	public boolean getIsCanAttackAirUnits() {
		return _IsCanAttackAirUnits;
	}

	/**
	 * 设置IsCanAttackAirUnits。 功能注释：是否可以攻击空中单位
	 * 
	 * @param value
	 *            要设置的boolean类型值
	 */
	public void setIsCanAttackAirUnits(boolean value) {
		_IsCanAttackAirUnits = value;
	}

	/**
	 * 设置IsCanAttackAirUnits为其默认值(false)。 功能注释：是否可以攻击空中单位
	 */
	public void setIsCanAttackAirUnitsToDefault() {
		setIsCanAttackAirUnits(false);
	}

	/**
	 * 计算目标是否在范围内
	 * 
	 * @param target
	 *            目标
	 * @return 是否在范围内
	 */
	protected boolean calculationIsInRange(ITDActor target) {
		return (target.getIsAirUnits() ? getIsCanAttackAirUnits()
				: getIsCanAttackGroundUnits())
				&& target.getPosition().minus(getPosition()).getLength()
						- target.getFinalStatus().getRadius() < getFinalStatus().getRange();
	}

	@Override
	public CopyOnWriteArrayList<ITDActor> getActorsInRange() {
		CopyOnWriteArrayList<ITDActor> a = new CopyOnWriteArrayList<ITDActor>();
		for (ITDActor f : TDWorld.getInstance().getActors()) {
			if (!f.equals(this)) {
				if (calculationIsInRange(f))
					a.add(f);
			}
		}
		return a;
	}

	@Override
	public CopyOnWriteArrayList<ITDTower> getTowersInRange() {
		CopyOnWriteArrayList<ITDTower> a = new CopyOnWriteArrayList<ITDTower>();
		for (ITDTower f : TDWorld.getInstance().getTowers()) {
			if (!f.equals(this)) {
				if (calculationIsInRange(f))
					a.add(f);
			}
		}
		return a;
	}

	@Override
	public CopyOnWriteArrayList<ITDBiont> getBiontInRange() {
		CopyOnWriteArrayList<ITDBiont> a = new CopyOnWriteArrayList<ITDBiont>();
		for (ITDBiont f : TDWorld.getInstance().getBiont()) {
			if (!f.equals(this)) {
				if (calculationIsInRange(f))
					a.add(f);
			}
		}
		return a;
	}

	@Override
	public ITDMapPiece getPlaceMapPiece() {
		return TDWorld.getInstance().getMap().getPieces()[(int) (getX() / TDWorld
				.getInstance().getMap().getPieceStandardSize().getX())][(int) (getY() / TDWorld
				.getInstance().getMap().getPieceStandardSize().getY())];
	}

	@Override
	public Vector2DF getSize() {
		return new Vector2DF(getRadius(), getRadius());
	}

	/**
	 * 攻击事件监听器列表
	 */
	private CopyOnWriteArrayList<ITDActorAttackListener> _AttackListenerList = null;

	@Override
	public void addOnAttackListener(ITDActorAttackListener listener) {
		if (_AttackListenerList == null)
			_AttackListenerList = new CopyOnWriteArrayList<ITDActorAttackListener>();
		if (!_AttackListenerList.contains(listener))
			_AttackListenerList.add(listener);
	}

	/**
	 * 移除攻击监听器
	 * 
	 * @param listener
	 *            监听器
	 */
	public void removeOnAttackListener(ITDActorAttackListener listener) {
		if (_AttackListenerList == null)
			return;
		if (_AttackListenerList.contains(listener))
			_AttackListenerList.remove(listener);
	}

	/**
	 * 发生攻击事件时
	 * 
	 * @param target
	 *            攻击目标
	 */
	protected void OnAttack(Collection<? extends ITDActor> target) {
		if (_AttackListenerList == null)
			return;
		for (ITDActorAttackListener f : _AttackListenerList) {
			f.onAttack(this, target);
		}
	}

	/**
	 * 遭受攻击事件监听器列表
	 */
	private CopyOnWriteArrayList<ITDActorUnderAttackListener> _UnderAttackListenerList = null;

	@Override
	public void addOnUnderAttackListener(ITDActorUnderAttackListener listener) {
		if (_UnderAttackListenerList == null)
			_UnderAttackListenerList = new CopyOnWriteArrayList<ITDActorUnderAttackListener>();
		if (!_UnderAttackListenerList.contains(listener))
			_UnderAttackListenerList.add(listener);
	}

	/**
	 * 移除遭受攻击监听器
	 * 
	 * @param listener
	 *            监听器
	 */
	public void removeOnUnderAttackListener(ITDActorUnderAttackListener listener) {
		if (_UnderAttackListenerList == null)
			return;
		if (_UnderAttackListenerList.contains(listener))
			_UnderAttackListenerList.remove(listener);
	}

	/**
	 * 发生遭受攻击事件时
	 * 
	 * @param source
	 *            袭击来源
	 * @param atk
	 *            来源的攻击力
	 */
	public void OnUnderAttack(ITDActor source, float atk) {
		int v = calculationDamage(atk);		

		if (_UnderAttackListenerList != null) {
			for (ITDActorUnderAttackListener f : _UnderAttackListenerList) {
				f.onUnderAttack(this, source, v);
			}
		}
		
		setHP(getHP() - v);
	}

	/**
	 * 计算伤害值
	 * 
	 * @param atk
	 *            来源的攻击力
	 * @return 伤害值
	 */
	protected int calculationDamage(float atk) {
		return (int) atk;
	}

	/**
	 * 死亡事件监听器列表
	 */
	private CopyOnWriteArrayList<ITDActorDieListener> _DieListenerList = null;

	@Override
	public void addOnDieListener(ITDActorDieListener listener) {
		if (_DieListenerList == null)
			_DieListenerList = new CopyOnWriteArrayList<ITDActorDieListener>();
		if (!_DieListenerList.contains(listener))
			_DieListenerList.add(listener);
	}

	/**
	 * 移除死亡监听器
	 * 
	 * @param listener
	 *            监听器
	 */
	public void removeOnDieListener(ITDActorDieListener listener) {
		if (_DieListenerList == null)
			return;
		if (_DieListenerList.contains(listener))
			_DieListenerList.remove(listener);
	}

	/**
	 * 发生死亡事件时
	 * 
	 * @param murderer
	 *            凶手
	 */
	protected void OnDie(ITDActor murderer) {
		if (_DieListenerList == null)
			return;
		for (ITDActorDieListener f : _DieListenerList) {
			f.onDie(this, murderer);
		}
	}

	/**
	 * 移动事件监听器列表
	 */
	private CopyOnWriteArrayList<ITDActorMoveListener> _MoveListenerList = null;

	@Override
	public void addOnMoveListener(ITDActorMoveListener listener) {
		if (_MoveListenerList == null)
			_MoveListenerList = new CopyOnWriteArrayList<ITDActorMoveListener>();
		if (!_MoveListenerList.contains(listener))
			_MoveListenerList.add(listener);
	}

	/**
	 * 移除移动监听器
	 * 
	 * @param listener
	 *            监听器
	 */
	public void removeOnMoveListener(ITDActorMoveListener listener) {
		if (_MoveListenerList == null)
			return;
		if (_MoveListenerList.contains(listener))
			_MoveListenerList.remove(listener);
	}

	/**
	 * 发生移动事件时
	 * 
	 * @param target
	 *            目标位置
	 */
	protected void OnMove(Vector2DF target) {
		if (_MoveListenerList == null)
			return;
		for (ITDActorMoveListener f : _MoveListenerList) {
			f.onMove(this, target);
		}
	}

	/**
	 * 站立事件监听器列表
	 */
	private CopyOnWriteArrayList<ITDActorStandListener> _StandListenerList = null;

	@Override
	public void addOnStandListener(ITDActorStandListener listener) {
		if (_StandListenerList == null)
			_StandListenerList = new CopyOnWriteArrayList<ITDActorStandListener>();
		if (!_StandListenerList.contains(listener))
			_StandListenerList.add(listener);
	}

	/**
	 * 移除站立监听器
	 * 
	 * @param listener
	 *            监听器
	 */
	public void removeOnStandListener(ITDActorStandListener listener) {
		if (_StandListenerList == null)
			return;
		if (_StandListenerList.contains(listener))
			_StandListenerList.remove(listener);
	}

	/**
	 * 发生站立事件时
	 */
	protected void OnStand() {
		if (_StandListenerList == null)
			return;
		for (ITDActorStandListener f : _StandListenerList) {
			f.onStand(this);
		}
	}
	
	/**
	 * 初始值为null。 功能注释：附加效果
	 */
	private ITDEffect _Effect = null;

	/**
	 * 获取Effect。 功能注释：附加效果
	 * 
	 * @return 当前的ITDEffect类型的值
	 */
	@Override
	public ITDEffect getEffect() {
		return _Effect;
	}

	/**
	 * 设置Effect。 功能注释：附加效果
	 * 
	 * @param value
	 *            要设置的ITDEffect类型值
	 */
	@Override
	public void setEffect(ITDEffect value) {
		if (value==null||_Effect == null) {
			_Effect = value;
			if(value!=null){
				value.setAttachTarget(this);
				OnAttachEffect(value);
			}
		} else
			_Effect.setEffect(value);
	}

	/**
	 * 设置Effect为其默认值(null)。 功能注释：附加效果
	 */
	public void setEffectToDefault() {
		setEffect(null);
	}

	@Override
	public ITDActor getFinalStatus() {
		ITDEffect e = getEffect();
		if (e != null)
			return e.getFinalStatus();
		return this;
	}

	/**
	 * 附加效果事件监听器列表
	 */
	private CopyOnWriteArrayList<ITDActorAttachEffectListener> _AttachEffectListenerList = null;

	@Override
	public void addOnAttachEffectListener(ITDActorAttachEffectListener listener) {
		if (_AttachEffectListenerList == null)
			_AttachEffectListenerList = new CopyOnWriteArrayList<ITDActorAttachEffectListener>();
		if (!_AttachEffectListenerList.contains(listener))
			_AttachEffectListenerList.add(listener);
	}

	/**
	 * 移除附加效果监听器
	 * 
	 * @param listener
	 *            监听器
	 */
	public void removeOnAttachEffectListener(ITDActorAttachEffectListener listener) {
		if (_AttachEffectListenerList == null)
			return;
		if (_AttachEffectListenerList.contains(listener))
			_AttachEffectListenerList.remove(listener);
	}

	/**
	 * 发生附加效果事件时
	 * 
	 * @param effect
	 *            附加的效果
	 */
	protected void OnAttachEffect(ITDEffect effect) {
		if (_AttachEffectListenerList == null)
			return;
		for (ITDActorAttachEffectListener f : _AttachEffectListenerList) {
			f.onAttachEffect(this, effect);
		}
	}
	
	/**
	 * 移除效果事件监听器列表
	 */
	private CopyOnWriteArrayList<ITDActorRemoveEffectListener> _RemoveEffectListenerList = null;

	@Override
	public void addOnRemoveEffectListener(ITDActorRemoveEffectListener listener) {
		if (_RemoveEffectListenerList == null)
			_RemoveEffectListenerList = new CopyOnWriteArrayList<ITDActorRemoveEffectListener>();
		if (!_RemoveEffectListenerList.contains(listener))
			_RemoveEffectListenerList.add(listener);
	}

	/**
	 * 移除移除效果监听器
	 * 
	 * @param listener
	 *            监听器
	 */
	public void removeOnRemoveEffectListener(ITDActorRemoveEffectListener listener) {
		if (_RemoveEffectListenerList == null)
			return;
		if (_RemoveEffectListenerList.contains(listener))
			_RemoveEffectListenerList.remove(listener);
	}

	/**
	 * 发生移除效果事件时
	 * 
	 * @param effect
	 *            移除的效果
	 */
	protected void OnRemoveEffect(ITDEffect effect) {
		if (_RemoveEffectListenerList == null)
			return;
		for (ITDActorRemoveEffectListener f : _RemoveEffectListenerList) {
			f.onRemoveEffect(this, effect);
		}
	}

	@Override
	public void removeEffect(ITDEffect value) {
		ITDActor t=null;
		if(_Effect==value){
			_Effect=value.getEffect();
			t=this;
		}
		else{
			t=value.getAttachTarget();
			t.setEffect(null);
			t.setEffect(value.getEffect());
		}
		ITDEffect e = t.getEffect();
		if(e!=null){
			e.setAttachTarget(t);
		}
		OnRemoveEffect(value);
	}
}
